// 双色球API服务
// 使用极速数据的免费API接口

// 1. 从Tauri HTTP插件中导入fetch，并重命名以避免冲突
import { fetch as tauriFetch } from '@tauri-apps/plugin-http';
import { invoke } from '@tauri-apps/api/core';
import { getVersion } from '@tauri-apps/api/app';

// --- 辅助变量和函数 ---

/**
 * 检测是否在 Tauri 环境中
 * 使用 getVersion API 进行可靠的环境检测
 */
/**
 * 检测是否在 Tauri 环境中运行
 * 使用多种方法进行检测以提高准确性
 */
export async function isTauri() {
  try {
    // 方法1: 检查 window.__TAURI__ 全局对象
    if (typeof window !== 'undefined' && window.__TAURI__) {
      return true;
    }
    
    // 方法2: 检查 Tauri API 是否可用
    if (typeof window !== 'undefined' && window.__TAURI_INTERNALS__) {
      return true;
    }
    
    // 方法3: 尝试调用 Tauri API
    await getVersion();
    return true;
  } catch (error) {
    console.log('Tauri 环境检测失败:', error.message);
    return false;
  }
}

// 全局 Tauri 环境状态 - 在模块加载时初始化
let IS_TAURI = true;
let IS_TAURI_INITIALIZED = false;

/**
 * 初始化 Tauri 环境检测
 * 在应用启动时调用一次，之后可以同步使用 IS_TAURI
 */
/**
 * 初始化 Tauri 环境检测
 * 在应用启动时调用，确保正确检测环境
 */
export async function initializeTauriDetection() {
  console.log('🚀 initializeTauriDetection 函数开始执行...');
  
  if (!IS_TAURI_INITIALIZED) {
    console.log('📋 开始进行 Tauri 环境检测...');
    
    // 添加延迟以确保 Tauri API 完全初始化
    await new Promise(resolve => setTimeout(resolve, 100));
    
    IS_TAURI = await isTauri();
    IS_TAURI_INITIALIZED = true;
    
    console.log('=== Tauri 环境检测结果 ===');
    console.log('IS_TAURI:', IS_TAURI);
    console.log('环境类型:', IS_TAURI ? 'Tauri桌面应用' : 'Web浏览器');
    console.log('User Agent:', navigator.userAgent);
    console.log('window.__TAURI__:', typeof window !== 'undefined' ? !!window.__TAURI__ : 'undefined');
    console.log('window.__TAURI_INTERNALS__:', typeof window !== 'undefined' ? !!window.__TAURI_INTERNALS__ : 'undefined');
    
    // 使用 alert 确保能看到结果（仅在开发环境）
    if (process.env.NODE_ENV === 'development') {
      setTimeout(() => {
        alert(`环境检测完成！\nIS_TAURI: ${IS_TAURI}\n环境: ${IS_TAURI ? 'Tauri桌面应用' : 'Web浏览器'}`);
      }, 500);
    }
  } else {
    console.log('✅ Tauri 环境检测已完成，当前状态:', IS_TAURI);
  }
  return IS_TAURI;
}



// 模块加载时自动初始化（可选）
// 注释掉，让应用主动调用初始化
// initializeTauriDetection().catch(console.error);

/**
 * 统一的API请求函数 ，自动区分Tauri环境和Web环境。
 * - 精简重复代码，统一 headers 与超时配置
 * - 集中化错误处理，确保异常时能看到清晰消息
 * @param {string} url - 请求的URL
 * @param {object} options - fetch的配置项
 * @returns {Promise<object>} - 解析后的JSON数据
 */
async function apiFetch(url, options = {}) {
  console.log('=== apiFetch 函数被调用 ===');
  console.log('输入参数 - URL:', url, 'Options:', options);
  
  // 使用同步方式获取 Tauri 环境状态
  const isTauriEnv = IS_TAURI;
  
  console.log('环境检查 - IS_TAURI:', isTauriEnv);
  console.log('window.__TAURI__:', !!window.__TAURI__);
  console.log('window.location.protocol:', window.location?.protocol);
  console.log('window.location.host:', window.location?.host);
  console.log('navigator.userAgent:', navigator.userAgent);
  
  const timeoutSec = options.timeout || 30;

  // 统一 headers 组装
  const baseHeaders = {
    'Accept': 'application/json, text/plain, */*',
    'Content-Type': 'application/json'
  };
  const androidUA = 'Mozilla/5.0 (Linux; Android 10; Mobile) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Mobile Safari/537.36';
  const headers = isTauriEnv
    ? { ...baseHeaders, 'User-Agent': androidUA, ...(options.headers || {}) }
    : { ...baseHeaders, ...(options.headers || {}) };

  // 在 Web 环境下将第三方 API URL 重写为本地代理路径，解决 CORS
  // 例如：https://api.jisuapi.com/caipiao/... => /caipiao/...
  console.log('环境检查 - IS_TAURI:', isTauriEnv, 'URL:', url);
  
  // 检查是否在React开发服务器环境下（通过端口判断）
  const isDevServer = window.location.port === '1430' || window.location.port === '3000';
  console.log('开发服务器检查 - port:', window.location.port, 'isDevServer:', isDevServer);
  
  const finalUrl = (!isTauriEnv && isDevServer && /^https?:\/\/api\.jisuapi\.com\/caipiao/i.test(url))
    ? url.replace(/^https?:\/\/api\.jisuapi\.com\/caipiao/i, '/caipiao')
    : (!isTauriEnv && isDevServer && /^https?:\/\/api\.jisuapi\.com\/.*/i.test(url))
    ? url.replace(/^https?:\/\/api\.jisuapi\.com/i, '/api')
    : url;
  
  console.log('URL转换结果 - 原始URL:', url, '转换后URL:', finalUrl);

  // 集中化错误转换为更友好的消息
  const toFriendlyError = (err) => {
    const offline = typeof navigator !== 'undefined' && !navigator.onLine;
    const envPrefix = isTauriEnv ? 'Tauri' : '浏览器';
    let message = err?.message || `${envPrefix}网络请求失败`;

    if (offline) {
      message = '网络连接不可用，请检查网络设置';
    } else if (err?.name === 'AbortError') {
      message = '请求超时，请检查网络连接';
    } else if (err?.name === 'TypeError' || /CORS|fetch/i.test(err?.message || '')) {
      message = '网络请求失败：可能是跨域(CORS)或网络问题';
    } else if (!message.trim()) {
      message = `${envPrefix}网络请求失败`;
    }

    return new Error(message);
  };

  // 统一的请求配置
  const fetchOptions = {
    method: options.method || 'GET',
    headers,
    ...(options.body && { body: options.body }),
    signal: AbortSignal.timeout(timeoutSec * 1000)
  };

  try {
    let response;
    
    // 根据环境选择请求方式
    if (isTauriEnv) {
      console.log('使用 Tauri fetch');
      response = await tauriFetch(finalUrl, fetchOptions);
    } else {
      console.log('使用标准 fetch');
      response = await fetch(finalUrl, fetchOptions);
    }

    console.log('响应状态:', response.status, response.statusText);
    console.log('响应头:', response.headers);

    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }

    const responseText = await response.text();
    console.log('响应文本长度:', responseText.length);
    console.log('响应文本前100字符:', responseText.substring(0, 100));

    if (!responseText.trim()) {
      throw new Error('服务器返回空响应');
    }

    let data;
    try {
      data = JSON.parse(responseText);
    } catch (parseError) {
      console.error('JSON解析失败:', parseError);
      console.error('原始响应:', responseText);
      throw new Error(`JSON解析失败: ${parseError.message}`);
    }

    console.log('解析后的数据:', data);
    return data;

  } catch (error) {
    console.error('apiFetch 错误:', error);
    
    // 增强错误信息
    const enhancedError = toFriendlyError(error);
    enhancedError.originalError = error;
    enhancedError.requestInfo = {
      url: finalUrl,
      method: fetchOptions.method,
      headers: fetchOptions.headers,
      env: isTauriEnv ? 'tauri' : 'web',
      timestamp: new Date().toISOString()
    };
    
    throw enhancedError;
  }
}

// --- 主要API服务类 ---

class LotteryApiService {
  // API配置
  static get API_BASE_URL() {
    // 统一使用HTTPS URL，Tauri环境已配置网络权限
    return 'https://api.jisuapi.com/caipiao';
  }

  // 检测当前运行环境
  static async getEnvironmentInfo() {
    const isAndroid = navigator.userAgent.includes('Android');
    const isTauriEnv = IS_TAURI;
    
    const envInfo = {
      isTauri: isTauriEnv,
      isAndroid: isAndroid,
      useDirectApi: isTauriEnv,
      isOnline: navigator.onLine,
      protocol: window.location.protocol,
      host: window.location.host,
      userAgent: navigator.userAgent,
      apiBaseUrl: this.API_BASE_URL
    };
    
    // 在Android环境中输出环境信息用于调试
    if (isAndroid) {
      // console.log('Android环境检测结果:', JSON.stringify(envInfo, null, 2));
    }
    
    return envInfo;
  }
  static APP_KEY = '92d6b37e3b476a14'; // 极速数据API密钥
  static APP_SECRET = 'gOmc4C45CiZvWiXfILdMS3S8MalTTGVI'; // 极速数据API密钥
  static LOTTERY_ID = 11; // 双色球的ID

  // 获取单期开奖结果
  static async getLotteryResult(issueno = '') {
    try {
      if (!navigator.onLine) throw new Error('网络连接不可用');

      const url = `${this.API_BASE_URL}/query`;
      const params = new URLSearchParams({
        appkey: this.APP_KEY,
        caipiaoid: this.LOTTERY_ID,
        issueno: issueno
      });

      const data = await apiFetch(`${url}?${params}`);

      if (data.status === 0) {
        return { success: true, data: data.result };
      } else {
        throw new Error(data.msg || '获取开奖结果失败');
      }
    } catch (error) {
      console.error('获取开奖结果失败:', error);
      return { success: false, error: error.message };
    }
  }

  // 获取历史开奖记录 - 使用 Tauri 命令
  static async getLotteryHistory(start = 0, num = 20, showDialog = false) {
    try {
      if (!navigator.onLine) throw new Error('网络连接不可用');

      // 在 Tauri 环境中使用 Rust 命令，否则使用原有的 fetch 方式
      const isTauriEnv = IS_TAURI;
      if (isTauriEnv) {
        console.log('>>> 执行 Tauri 分支');
        console.log('=== 使用 Tauri 命令获取历史记录 ===');
        console.log('参数:', { start, num, showDialog });
        
        // 调用 Tauri 命令：参数命名需与 Rust 端一致（snake_case）
        const response = await invoke('get_lottery_history', {
          appKey: this.APP_KEY,
          lotteryId: this.LOTTERY_ID.toString(),
          start: start,
          num: Math.min(num, 20)
        });
        
        console.log('Tauri 命令响应:', response);
        
        // 处理 Tauri 命令的响应
        if (response && response.success) {
          console.log(`Tauri 命令成功获取 ${response.data.length} 条历史记录`);
          return { success: true, data: response.data };
        } else {
          throw new Error(response?.error || 'Tauri 命令执行失败');
        }
      } else {
        console.log('>>> 执行 Web 分支');
        console.log('=== 使用 HTTP 请求获取历史记录 ===');
        
        const url = `${this.API_BASE_URL}/history`;
        const params = new URLSearchParams({
          appkey: this.APP_KEY,
          caipiaoid: this.LOTTERY_ID,
          start: start,
          num: Math.min(num, 20)
        });

        const data = await apiFetch(`${url}?${params}`);

        if (data.status === 0) {
          console.log(`HTTP 请求成功获取 ${data.result.length} 条历史记录`);
          return { success: true, data: data.result };
        } else {
          throw new Error(data.msg || '获取历史记录失败');
        }
      }
    } catch (error) {
      console.error('=== 获取历史记录失败 ===');
      console.error('异常类型:', error.name);
      console.error('异常消息:', error.message);
      console.error('异常堆栈:', error.stack);
      
      // 详细错误诊断（所有环境）
      console.error('=== 环境错误诊断 ===');
      console.error('网络状态:', navigator.onLine ? '在线' : '离线');
      console.error('用户代理:', navigator.userAgent);
      const isTauriEnv = IS_TAURI;
      console.error('Tauri环境检测:', isTauriEnv);
      console.error('当前环境:', navigator.userAgent.includes('Android') ? 'Android' : 
                   isTauriEnv ? 'Tauri桌面' : 'Web浏览器');
      console.error('请求方式:', isTauriEnv ? 'Tauri命令' : 'HTTP请求');
      console.error('API密钥配置:', this.isApiKeyConfigured() ? '已配置' : '未配置');
      
      // 检查错误类型并提供相应的解决建议
      let errorSuggestion = '';
      if ((error.message && error.message.includes('fetch')) || error.name === 'TypeError') {
        errorSuggestion = '网络连接问题，请检查网络设置或API服务器状态';
      } else if ((error.message && error.message.includes('timeout')) || error.name === 'AbortError') {
        errorSuggestion = '请求超时，请检查网络速度或稍后重试';
      } else if (error.message && error.message.includes('JSON')) {
        errorSuggestion = 'API响应格式错误，可能是服务器问题';
      } else if (error.message && error.message.includes('invoke')) {
        errorSuggestion = 'Tauri命令调用失败，请检查后端服务是否正常';
      } else if (!error.message || error.message === 'undefined' || error.message.trim() === '') {
        errorSuggestion = '未知错误，建议查看详细日志或联系技术支持';
      } else {
        errorSuggestion = '请查看详细错误信息或尝试重新请求';
      }
      
      console.error('错误建议:', errorSuggestion);
      
      // 确保错误消息不为undefined
      const finalErrorMessage = typeof error === 'string' 
        ? error 
        : (error?.message || `API请求失败: ${error?.name || 'Unknown Error'}`);
      
      // 弹窗逻辑可以根据需要保留或简化
      if (showDialog && window.Modal) {
        const isAndroid = navigator.userAgent.includes('Android');
        window.Modal.error({ 
          title: 'API请求失败', 
          content: (
            <div>
              <p><strong>错误信息:</strong> {finalErrorMessage}</p>
              <p><strong>环境信息:</strong> {isAndroid ? 'Android Tauri' : isTauriEnv ? 'Tauri桌面' : 'Web浏览器'}</p>
              <p><strong>请求方式:</strong> {isTauriEnv ? 'Tauri命令' : 'HTTP请求'}</p>
              {isAndroid && (
                <div style={{ marginTop: 10, padding: 10, background: '#f5f5f5', borderRadius: 4 }}>
                  <p><strong>Android调试信息:</strong></p>
                  <p>网络状态: {navigator.onLine ? '在线' : '离线'}</p>
                  <p>Tauri环境: {isTauriEnv ? '是' : '否'}</p>
                  <p>API密钥: {this.isApiKeyConfigured() ? '已配置' : '未配置'}</p>
                </div>
              )}
            </div>
          )
        });
      }
      return { success: false, error: finalErrorMessage };
    }
  }

  // 获取过去一个月的开奖记录 - 使用 Tauri 命令优化
  static async getRecentMonthHistory(showDialog = false) {
    try {
      console.log('=== 开始获取近一个月历史记录 ===');
      
      // 在 Tauri 环境中，可以直接使用专门的命令获取一个月的数据
      const isTauriEnv = IS_TAURI;
      if (isTauriEnv) {
        console.log('=== 使用 Tauri 命令获取近一个月历史记录 ===');
        
        // 调用 Tauri 优化命令：参数命名需与 Rust 端一致（snake_case）
        const recentData = await invoke('get_recent_month_history', {
          appKey: this.APP_KEY,
          lotteryId: this.LOTTERY_ID.toString()
        });
        
        console.log('Tauri 命令返回的近一个月数据:', recentData);
        console.log(`获取到 ${recentData.length} 条近一个月的记录`);

        return {
          success: true,
          data: recentData,
          total: recentData.length,
          requestMethod: 'tauri_invoke'
        };
      }
    } catch (error) {
      console.error('获取近一个月历史记录失败:', error);
      const errorMessage = typeof error === 'string' ? error : (error?.message || `获取历史记录失败: ${error?.name || 'Unknown Error'}`);
      
      if (showDialog && window.Modal) {
        window.Modal.error({
          title: '获取历史记录失败',
          content: `错误信息: ${errorMessage}`,
          width: 600
        });
      }
      
      return {
        success: false,
        error: errorMessage
      };
    }
  }

  // 获取彩票分类信息
  static async getLotteryTypes() {
    try {
      if (!navigator.onLine) throw new Error('网络连接不可用');

      const url = `${this.API_BASE_URL}/class`;
      const params = new URLSearchParams({ appkey: this.APP_KEY });

      const data = await apiFetch(`${url}?${params}`);

      if (data.status === 0) {
        return { success: true, data: data.result };
      } else {
        throw new Error(data.msg || '获取彩票分类失败');
      }
    } catch (error) {
      console.error('获取彩票分类失败:', error);
      return { success: false, error: error.message };
    }
  }

  // 检查中奖情况
  static async checkWinning(numbers, refernumber, issueno = '') {
    try {
      if (!numbers || !refernumber) {
        throw new Error('请提供完整的号码信息');
      }

      const url = `${this.API_BASE_URL}/winning`;
      const params = new URLSearchParams({
        appkey: this.APP_KEY,
        caipiaoid: this.LOTTERY_ID,
        numbers: numbers,
        refernumber: refernumber,
        issueno: issueno
      });

      const data = await apiFetch(`${url}?${params}`);

      if (data.status === 0) {
        return { success: true, data: data.result };
      } else {
        throw new Error(data.msg || '检查中奖失败');
      }
    } catch (error) {
      console.error('检查中奖失败:', error);
      return { success: false, error: error.message };
    }
  }

  // 延迟函数
  static delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  // 格式化彩票号码显示
  static formatLotteryNumbers(numberStr, refernumberStr) {
    try {
      if (!numberStr || !refernumberStr) return null;
      
      const numbers = numberStr.split(',').map(n => n.trim()).filter(n => n);
      const refernumber = refernumberStr.split(',').map(n => n.trim()).filter(n => n);
      
      return {
        redBalls: numbers,
        blueBalls: refernumber,
        display: `${numbers.join(', ')} + ${refernumber.join(', ')}`
      };
    } catch (error) {
      console.error('格式化号码失败:', error);
      return null;
    }
  }

  // 检查API密钥是否配置
  static isApiKeyConfigured() {
    return !!(this.APP_KEY && this.APP_KEY.trim() && this.APP_KEY !== 'your_api_key_here');
  }

  // 网络诊断功能
  static async networkDiagnosis() {
    const diagnosis = {
      timestamp: new Date().toISOString(),
      environment: {},
      network: {},
      api: {},
      tauri: {}
    };

    try {
      // 环境检测
      const isTauriEnv = await isTauri();
      diagnosis.environment = {
        isTauri: isTauriEnv,
        isAndroid: navigator.userAgent.includes('Android'),
        isOnline: navigator.onLine,
        protocol: window.location.protocol,
        host: window.location.host,
        port: window.location.port,
        userAgent: navigator.userAgent.substring(0, 100) + '...',
        language: navigator.language,
        platform: navigator.platform
      };

      // 网络状态检测
      diagnosis.network = {
        onLine: navigator.onLine,
        effectiveType: navigator.connection?.effectiveType || 'unknown',
        downlink: navigator.connection?.downlink || 'unknown',
        rtt: navigator.connection?.rtt || 'unknown'
      };

      // API配置检测
      diagnosis.api = {
        baseUrl: this.API_BASE_URL,
        hasApiKey: this.isApiKeyConfigured(),
        apiKeyLength: this.APP_KEY ? this.APP_KEY.length : 0,
        lotteryId: this.LOTTERY_ID
      };

      // Tauri特定检测
      if (isTauriEnv) {
        try {
          diagnosis.tauri = {
            hasWindow: !!window.__TAURI__,
            hasInvoke: typeof invoke === 'function',
            hasTauriFetch: typeof tauriFetch === 'function',
            version: await getVersion().catch(() => 'unknown')
          };
        } catch (error) {
          diagnosis.tauri.error = error.message;
        }
      }

      // 简单的网络连通性测试
      try {
        const testUrl = isTauriEnv ? this.API_BASE_URL : '/caipiao';
        const testParams = new URLSearchParams({
          appkey: this.APP_KEY,
          caipiaoid: this.LOTTERY_ID
        });
        
        console.log('开始网络连通性测试...');
        const startTime = Date.now();
        
        // 使用较短的超时时间进行测试
        const testResult = await apiFetch(`${testUrl}/query?${testParams}`, { timeout: 5 });
        const endTime = Date.now();
        
        diagnosis.api.connectivity = {
          success: true,
          responseTime: endTime - startTime,
          hasData: !!testResult
        };
      } catch (error) {
        diagnosis.api.connectivity = {
          success: false,
          error: error.message,
          errorType: error.name
        };
      }

      console.log('网络诊断完成:', diagnosis);
      return diagnosis;

    } catch (error) {
      console.error('网络诊断失败:', error);
      diagnosis.error = error.message;
      return diagnosis;
    }
  }

  // 显示诊断模态框
  static async showDiagnosisModal() {
    if (!window.Modal) {
      console.error('Modal组件不可用');
      return;
    }

    const diagnosis = await this.networkDiagnosis();
    const isTauriEnv = IS_TAURI;
    
    window.Modal.info({
      title: '网络与环境诊断',
      width: 800,
      content: (
        <div style={{ maxHeight: '500px', overflow: 'auto' }}>
          <h4>🔍 环境信息</h4>
          <table style={{ width: '100%', borderCollapse: 'collapse', marginBottom: '20px' }}>
            <tbody>
              <tr><td style={{ padding: '4px', border: '1px solid #ddd', fontWeight: 'bold' }}>运行环境</td><td style={{ padding: '4px', border: '1px solid #ddd' }}>{isTauriEnv ? 'Tauri桌面应用' : 'Web浏览器'}</td></tr>
              <tr><td style={{ padding: '4px', border: '1px solid #ddd', fontWeight: 'bold' }}>操作系统</td><td style={{ padding: '4px', border: '1px solid #ddd' }}>{diagnosis.environment.platform}</td></tr>
              <tr><td style={{ padding: '4px', border: '1px solid #ddd', fontWeight: 'bold' }}>网络状态</td><td style={{ padding: '4px', border: '1px solid #ddd' }}>{diagnosis.environment.isOnline ? '✅ 在线' : '❌ 离线'}</td></tr>
              <tr><td style={{ padding: '4px', border: '1px solid #ddd', fontWeight: 'bold' }}>访问地址</td><td style={{ padding: '4px', border: '1px solid #ddd' }}>{diagnosis.environment.protocol}//{diagnosis.environment.host}</td></tr>
            </tbody>
          </table>

          <h4>🌐 网络连接</h4>
          <table style={{ width: '100%', borderCollapse: 'collapse', marginBottom: '20px' }}>
            <tbody>
              <tr><td style={{ padding: '4px', border: '1px solid #ddd', fontWeight: 'bold' }}>连接类型</td><td style={{ padding: '4px', border: '1px solid #ddd' }}>{diagnosis.network.effectiveType}</td></tr>
              <tr><td style={{ padding: '4px', border: '1px solid #ddd', fontWeight: 'bold' }}>下载速度</td><td style={{ padding: '4px', border: '1px solid #ddd' }}>{diagnosis.network.downlink} Mbps</td></tr>
              <tr><td style={{ padding: '4px', border: '1px solid #ddd', fontWeight: 'bold' }}>网络延迟</td><td style={{ padding: '4px', border: '1px solid #ddd' }}>{diagnosis.network.rtt} ms</td></tr>
            </tbody>
          </table>

          <h4>🔧 API配置</h4>
          <table style={{ width: '100%', borderCollapse: 'collapse', marginBottom: '20px' }}>
            <tbody>
              <tr><td style={{ padding: '4px', border: '1px solid #ddd', fontWeight: 'bold' }}>API地址</td><td style={{ padding: '4px', border: '1px solid #ddd' }}>{diagnosis.api.baseUrl}</td></tr>
              <tr><td style={{ padding: '4px', border: '1px solid #ddd', fontWeight: 'bold' }}>API密钥</td><td style={{ padding: '4px', border: '1px solid #ddd' }}>{diagnosis.api.hasApiKey ? '✅ 已配置' : '❌ 未配置'}</td></tr>
              <tr><td style={{ padding: '4px', border: '1px solid #ddd', fontWeight: 'bold' }}>连通性测试</td><td style={{ padding: '4px', border: '1px solid #ddd' }}>
                {diagnosis.api.connectivity?.success ? 
                  `✅ 成功 (${diagnosis.api.connectivity.responseTime}ms)` : 
                  `❌ 失败: ${diagnosis.api.connectivity?.error || '未知错误'}`
                }
              </td></tr>
            </tbody>
          </table>

          {isTauriEnv && (
            <>
              <h4>🖥️ Tauri环境</h4>
              <table style={{ width: '100%', borderCollapse: 'collapse', marginBottom: '20px' }}>
                <tbody>
                  <tr><td style={{ padding: '4px', border: '1px solid #ddd', fontWeight: 'bold' }}>Tauri窗口</td><td style={{ padding: '4px', border: '1px solid #ddd' }}>{diagnosis.tauri.hasWindow ? '✅ 可用' : '❌ 不可用'}</td></tr>
                  <tr><td style={{ padding: '4px', border: '1px solid #ddd', fontWeight: 'bold' }}>命令调用</td><td style={{ padding: '4px', border: '1px solid #ddd' }}>{diagnosis.tauri.hasInvoke ? '✅ 可用' : '❌ 不可用'}</td></tr>
                  <tr><td style={{ padding: '4px', border: '1px solid #ddd', fontWeight: 'bold' }}>HTTP插件</td><td style={{ padding: '4px', border: '1px solid #ddd' }}>{diagnosis.tauri.hasTauriFetch ? '✅ 可用' : '❌ 不可用'}</td></tr>
                  <tr><td style={{ padding: '4px', border: '1px solid #ddd', fontWeight: 'bold' }}>应用版本</td><td style={{ padding: '4px', border: '1px solid #ddd' }}>{diagnosis.tauri.version}</td></tr>
                </tbody>
              </table>
            </>
          )}

          <h4>📋 详细信息</h4>
          <pre style={{ 
            background: '#f5f5f5', 
            padding: '10px', 
            borderRadius: '4px', 
            fontSize: '12px',
            maxHeight: '200px',
            overflow: 'auto'
          }}>
            {JSON.stringify(diagnosis, null, 2)}
          </pre>
        </div>
      )
    });
  }

  // 获取模拟数据（用于测试）
  static getMockData() {
    return {
      success: true,
      data: [
        {
          issueno: '2024001',
          opendate: '2024-01-01',
          number: '01,05,12,18,25,33',
          refernumber: '08',
          remark: '模拟数据'
        },
        {
          issueno: '2024002', 
          opendate: '2024-01-04',
          number: '03,08,15,22,28,31',
          refernumber: '12',
          remark: '模拟数据'
        }
      ]
    };
  }
}

export default LotteryApiService;